home *** CD-ROM | disk | FTP | other *** search
/ Hackers Handbook - Millenium Edition / Hackers Handbook.iso / files / c_scripts / fspscan.c / fspscan.c next >
Encoding:
C/C++ Source or Header  |  1994-05-19  |  9.0 KB  |  379 lines
  1. /*********************************************************************\
  2. *  Copyright (c) 1991 by Wen-King Su (wen-king@vlsi.cs.caltech.edu)   *
  3. *                                                                     *
  4. *  You may copy or modify this file in any manner you wish, provided  *
  5. *  that this notice is always included, and that you hold the author  *
  6. *  harmless for any loss or damage resulting from the installation or *
  7. *  use of this software.                                              *
  8. \*********************************************************************/
  9.  
  10.  
  11. /****************************************************************
  12.  * FindPort -- hack of fver to find valid ports on a FSP server *
  13.  * by Cuda.  Yes, it's ugly, but it works for me.               *
  14.  * Type "fspscan -h" to see how it is used.                     *
  15.  ****************************************************************/
  16.  
  17. #include "fspscan.h"
  18. #include <netdb.h>
  19.  
  20. char *host = NULL;
  21. char *outputfile = NULL;
  22. /* Default values */
  23. int  localport = 9191; 
  24. int  remoteport = 21;
  25. int  retries = 3;
  26. int  client_trace = 0;
  27. int  errno;
  28.  
  29. static int myfd;
  30. static struct sockaddr_in server_addr;
  31. static unsigned short myseq = 0;
  32. static unsigned short key;
  33. int client_intr_state = 0;
  34.  
  35. static struct sockaddr_in INET_ZERO = { AF_INET };
  36.  
  37. #define DSIZE (sizeof(int)*8)
  38. #define SAVE(A) { int sav; sav = errno; A; errno = sav; }
  39.  
  40. long inet_addr();
  41.  
  42. main(argc,argv)
  43. int argc;
  44. char **argv;
  45. {
  46.     int  i;
  47.     UBUF *ub;
  48.     FILE *logfile;
  49.     extern char *optarg;
  50.  
  51.     while ((i = getopt(argc, argv, "htp:o:r:l:i:")) != EOF) {
  52.     switch(i) {
  53.     case 'h':
  54.         printhelp(argc, argv);
  55.         break;
  56.         case 't':
  57.         client_trace=1;
  58.         break;
  59.         case 'r':
  60.         retries=atoi(optarg);
  61.         break;
  62.     case 'p':
  63.         remoteport=atoi(optarg);
  64.         break;
  65.     case 'l':
  66.         localport=atoi(optarg);
  67.         break;
  68.     case 'i':
  69.         host = (char *) malloc(strlen(optarg)+1);
  70.         strcpy(host, optarg);
  71.         break;
  72.         case 'o':
  73.         outputfile = (char *) malloc(strlen(optarg)+1);
  74.         strcpy(outputfile, optarg);
  75.         break;
  76.     case '?':
  77.         printhelp(argc, argv);
  78.         break;
  79.     default:
  80.         fprintf(stderr,"This error should not happen\n");
  81.     }
  82.     }
  83.         
  84.     if (host == NULL) {
  85.         fprintf(stderr, "host/ip not specified, unable to continue\n");
  86.     printhelp(argc, argv);
  87.     exit(-1);
  88.     }
  89.  
  90.     if (outputfile == NULL) {
  91.     logfile=stdout;
  92.     } else {
  93.         logfile=fopen(outputfile,"a+");
  94.     }
  95.  
  96.     fprintf(logfile,"Scanning %s\n",host);
  97.  
  98.     for ( ; ; ++remoteport) {
  99.         init_client(host,remoteport,localport);
  100.         signal(SIGINT,client_intr);
  101.  
  102.         ub = client_interact(CC_VERSION,0L, 0,NULLP, 0,NULLP);
  103.     if (ub)
  104.         /* success! */
  105.             fprintf(logfile,"Found FSP ver: %s on port %0d\n",
  106.                 ub->buf,remoteport);
  107.         else
  108.         fprintf(logfile,"%0d...nada\n",remoteport); 
  109.         fflush(logfile);
  110.         fdclose();
  111.     }
  112. }
  113.  
  114. printhelp(argc,argv)
  115. int argc;
  116. char **argv;
  117. {
  118.     fprintf(stderr,"%s - an fsp port scanner\n",argv[0]);
  119.     fprintf(stderr,"Usage: %s [-h]\n",argv[0]);
  120.     fprintf(stderr,"       (prints this help screen)\n");
  121.     fprintf(stderr,"       %s [-t][-o file][-r retries][-l local port][-i ip address][-p starting port]\n\n",argv[0]);
  122.     fprintf(stderr,"Defaults: (-o) file = stdout\n");
  123.     fprintf(stderr,"          (-l) local port = 9191\n");
  124.     fprintf(stderr,"          (-p) starting port = 21\n");
  125.     fprintf(stderr,"          (-r) retries = 3\n");
  126.     fprintf(stderr,"          (-t) trace = off\n");
  127.     fprintf(stderr,"          (-i) host-ip = none (host MUST be specified)\n");
  128.     exit(0);
  129. }
  130.  
  131.  
  132. UBUF *client_interact(cmd,pos,l1,p1,l2,p2)
  133.     unsigned cmd, l1, l2;
  134.     unsigned long pos;
  135.     unsigned char *p1, *p2;
  136. {
  137.     struct sockaddr_in from;
  138.     UBUF sbuf;
  139.     static UBUF rbuf;
  140.     unsigned char *s, *t, *d;
  141.     unsigned u, n, sum, mask, mlen;
  142.     int retval, bytes, retry;
  143.  
  144.     sbuf.cmd = cmd;
  145.     sbuf.len = htons(l1);
  146.     sbuf.pos = htonl(pos);
  147.  
  148.     client_intr_state = 1;
  149.  
  150.     for(u = l1, d = (unsigned char *) sbuf.buf; u--; *d++ = *p1++);
  151.     for(u = l2                      ; u--; *d++ = *p2++);
  152.     mlen = d - (unsigned char *) &sbuf;
  153.  
  154.     for(retry = 0; retry < retries; retry++) {
  155.     sbuf.key = key;
  156.     sbuf.seq = myseq;
  157.     sbuf.sum = 0;
  158.  
  159.     for(t = (unsigned char *) &sbuf, sum = n = mlen; n--; sum += *t++);
  160.     sbuf.sum = sum + (sum >> 8);
  161.     if(client_trace && retry) 
  162.         write(2,"R",1);
  163.  
  164.     if(sendto(myfd,&sbuf,mlen,0,&server_addr,sizeof(server_addr)) == -1)
  165.                         { perror("sendto"); exit(1); }
  166.     mask = 1 << myfd;
  167.  
  168.     while(1) {
  169.         retval = _x_select(&mask, 3000L);
  170.  
  171.         if((retval == -1) && (errno = EINTR)) continue;
  172.  
  173.         if(retval == 1) {  /* an incoming message is waiting */
  174.         bytes = sizeof(from);
  175.         if((bytes = recvfrom(myfd,(char*)&rbuf,sizeof(rbuf),0,
  176.                     &from,&bytes)) < UBUF_HSIZE) continue;
  177.  
  178.         s = (unsigned char *) &rbuf;
  179.         d = s + bytes;
  180.         u = rbuf.sum; rbuf.sum = 0;
  181.         for(t = s, sum = 0; t < d; sum += *t++);
  182.         sum = (sum + (sum >> 8)) & 0xff;
  183.         if(sum != u) continue;  /* wrong check sum */
  184.  
  185.         rbuf.len = htons(rbuf.len);
  186.         rbuf.pos = htonl(rbuf.pos);
  187.  
  188.         if(rbuf.seq           != myseq) continue;  /* wrong seq # */
  189.         if(rbuf.len+UBUF_HSIZE > bytes) continue;  /* truncated.  */
  190.  
  191.         myseq++; key = rbuf.key;    /* update seq and keys.   */
  192.  
  193.         if(client_intr_state == 2) { client_done(); exit(1); }
  194.  
  195.         return(&rbuf);
  196.  
  197.         } else break;   /* go back to re-transmit buffer again */
  198.     }
  199.     }
  200.     /* return NULL if there have been too many retries - ffindport hack */
  201.     return(NULL);
  202. }
  203.  
  204.  
  205. init_client(host,port,myport)
  206.     char *host;
  207.     int   port;
  208.     int myport;
  209. {
  210.     if((myfd = _x_udp(&myport)) == -1)
  211.         { perror("socket open"); exit(1); }
  212.  
  213.     if(_x_adr(host,port,&server_addr) == -1)
  214.         { perror("server addr"); exit(1); } 
  215. }
  216.  
  217. client_done()
  218. {
  219.     (void) client_interact(CC_BYE,0L,0,NULLP,0,NULLP);
  220. }
  221.  
  222. void client_intr()
  223. {
  224.     switch(client_intr_state) {
  225.         case 0: exit(2);
  226.         case 1: client_intr_state = 2; break;
  227.         case 2: exit(3);
  228.     }
  229. }
  230.  
  231. fdclose()
  232. {
  233.     close(myfd);
  234. }
  235.  
  236.  
  237. #ifndef EXOS_IPC
  238.  
  239. _x_udp(port)
  240.     int *port;
  241. {
  242.     int f, len, zz;
  243.     struct sockaddr_in me ;
  244.     struct sockaddr_in sin;
  245.  
  246.     me = sin = INET_ZERO;
  247.  
  248.     me.sin_port = htons((unsigned short) *port);
  249.     me.sin_family = AF_INET;
  250.  
  251.     if((f=socket(AF_INET,SOCK_DGRAM,0)) == -1) return(-1);
  252.  
  253.     if( setsockopt(f,SOL_SOCKET,SO_REUSEADDR,(int)&zz,sizeof(zz)) < 0 ||
  254.         bind(f,(struct sockaddr *) &me,(len = sizeof(me))) < 0 ||
  255.         getsockname(f,(char *)&sin,&len) < 0)
  256.                                 { SAVE(((void) close(f))); return(-1); }
  257.     if(!*port) *port = ntohs((unsigned short) sin.sin_port); return(f);
  258. }      
  259.  
  260. _x_adr(host,port,his)
  261.     struct sockaddr_in *his;
  262.     char *host;
  263.     int port;
  264. {
  265.     char myhost[128];
  266.     struct hostent *H;
  267.     int    i;
  268.     char *s, *d;
  269.  
  270.     *his = INET_ZERO;
  271.     if(!host) (void) gethostname(host = myhost,sizeof(myhost));
  272.  
  273.     if((his->sin_addr.s_addr = inet_addr(host)) != -1) {   
  274.     his->sin_family = AF_INET;
  275.     } else
  276.     if(H = gethostbyname(host)) {   
  277.     for(s = (char *)H->h_addr, 
  278.         d = (char *)&his->sin_addr, 
  279.         i = H->h_length; i--; *d++ = *s++);
  280.         his->sin_family = H->h_addrtype;
  281.     } else return(-1);
  282.     his->sin_port = htons((unsigned short) port);
  283.  
  284.     return(0);
  285. }
  286.  
  287. _x_select(rf, tt)       /* tt is in unit of ms */
  288.     int *rf;
  289.     long tt;
  290. {
  291.     struct timeval timeout;
  292.  
  293.     if(tt != -1)
  294.     {
  295.         timeout.tv_sec  =  tt / 1000;
  296.         timeout.tv_usec = (tt % 1000)*1000;
  297.         return(select(DSIZE, rf, (int *) 0, (int *) 0, &timeout));
  298.     }
  299.        
  300.     return(select(DSIZE, rf, (int *) 0, (int *) 0, (struct timeval *) 0));
  301. }
  302. #endif  /* not EXOS_IPC */
  303.  
  304.  
  305. #ifdef EXOS_IPC
  306.  
  307. extern long rhost();
  308.  
  309. _x_udp(port)
  310.     int *port;
  311. {
  312.     struct sockaddr_in sin; int f;
  313.  
  314.     sin = INET_ZERO;
  315.     sin.sin_family = AF_INET;
  316.     sin.sin_port   = htons((unsigned short) *port);
  317.     if((f = socket(SOCK_DGRAM, (struct sockproto *) 0, &sin, SO_REUSEADDR))
  318.                             == -1) return(-1);
  319.     sin = INET_ZERO;
  320.     if(socketaddr(f,&sin) == -1) { SAVE(((void) close(f))); return(-1); }
  321.     if(!*port) *port = ntohs((unsigned short) sin.sin_port); return(f);
  322. }
  323.  
  324. _x_adr(host,port,his)
  325.     char *host;
  326.     int port;
  327.     struct sockaddr_in *his;
  328. {
  329.     char myhost[128];
  330.     int f;
  331.  
  332.     *his = INET_ZERO;
  333.     if(!host) (void) gethostname(host = myhost,sizeof(myhost));
  334.  
  335.     his->sin_family = AF_INET;
  336.     his->sin_port   = htons((unsigned short) port);
  337.  
  338.     if((his->sin_addr.s_addr = rhost(&host)) == -1) return(-1);
  339.  
  340.     return(0);
  341. }
  342.  
  343. _x_select(readfds, tt)
  344.     int *readfds;
  345.     long tt;                /* Time to wait in miniseconds. */
  346. {
  347.     int  code;
  348.     long mask = *readfds;
  349.  
  350.     if(tt & 0xc0000000) tt = 0x3fffffff;/* It does not like 0x7fffffff. */
  351.  
  352.     code = select(DSIZE, &mask, (long *) 0, tt);
  353.  
  354.     *readfds = mask;
  355.  
  356.     return(code);
  357. }
  358.  
  359. recvfrom(s, msg, len, flags, from, fromlen)
  360.     char *msg;
  361.     int s, len, flags, *fromlen;
  362.     struct sockaddr_in *from;
  363. {
  364.     return(receive(s,from,msg,len));
  365. }
  366.  
  367. sendto(s, msg, len, flags, to, tolen)
  368.     char *msg;
  369.     int s, len, flags, tolen;
  370.     struct sockaddr_in *to;
  371. {
  372.      to->sin_family = AF_INET;
  373.      return(send(s,to,msg,len));
  374. }
  375.  
  376. #endif /* EXOS_IPC */
  377.  
  378.  
  379.